home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / language / iconv8_s.arc / ICONT.ARC / TREE.C < prev    next >
C/C++ Source or Header  |  1990-03-28  |  4KB  |  200 lines
  1. /*
  2.  * tree.c -- functions for constructing parse trees
  3.  */
  4.  
  5. #include "..\h\config.h"
  6. #include "general.h"
  7. #include "tproto.h"
  8. #include "tree.h"
  9.  
  10. /*
  11.  *  tree[1-6] construct parse tree nodes with specified values.  tfree
  12.  *   points at the next free word in the parse tree space.  Nodes are
  13.  *   built by copying argument values into successive locations starting
  14.  *   at tfree.  Parameters a and b are line and column information,
  15.  *   while parameters c through f are values to be assigned to n_field[0-3].
  16.  *   Note that this could be done with a single routine; a separate routine
  17.  *   for each node size is used for speed and simplicity.
  18.  */
  19.  
  20. nodeptr tree1(type)
  21. int type;
  22.    {
  23.    register nodeptr t;
  24.  
  25.    t = tfree;
  26.    tfree = (nodeptr) ((word *)tfree + 1);
  27.    if (tfree > tend)
  28.       tsyserr("out of tree space");
  29.    t->n_type = type;
  30.    return t;
  31.    }
  32.  
  33. nodeptr tree2(type, loc_model)
  34. int type;
  35. nodeptr loc_model;
  36.    {
  37.    register nodeptr t;
  38.  
  39.    t = tfree;
  40.    tfree = (nodeptr) ((word *)tfree + 4);
  41.    if (tfree > tend)
  42.       tsyserr("out of tree space");
  43.    t->n_type = type;
  44.    t->n_file = loc_model->n_file;
  45.    t->n_line = loc_model->n_line;
  46.    t->n_col = loc_model->n_col;
  47.    return t;
  48.    }
  49.  
  50. nodeptr tree3(type, loc_model, c)
  51. int type;
  52. nodeptr loc_model;
  53. nodeptr c;
  54.    {
  55.    register nodeptr t;
  56.  
  57.    t = tfree;
  58.    tfree = (nodeptr) ((word *)tfree + 5);
  59.    if (tfree > tend)
  60.       tsyserr("out of tree space");
  61.    t->n_type = type;
  62.    t->n_file = loc_model->n_file;
  63.    t->n_line = loc_model->n_line;
  64.    t->n_col = loc_model->n_col;
  65.    t->n_field[0].n_ptr = c;
  66.    return t;
  67.    }
  68.  
  69. nodeptr tree4(type, loc_model, c, d)
  70. int type;
  71. nodeptr loc_model;
  72. nodeptr c, d;
  73.    {
  74.    register nodeptr t;
  75.  
  76.    t = tfree;
  77.    tfree = (nodeptr) ((word *)tfree + 6);
  78.    if (tfree > tend)
  79.       tsyserr("out of tree space");
  80.    t->n_type = type;
  81.    t->n_file = loc_model->n_file;
  82.    t->n_line = loc_model->n_line;
  83.    t->n_col = loc_model->n_col;
  84.    t->n_field[0].n_ptr = c;
  85.    t->n_field[1].n_ptr = d;
  86.    return t;
  87.    }
  88.  
  89. nodeptr tree5(type, loc_model, c, d, e)
  90. int type;
  91. nodeptr loc_model;
  92. nodeptr c, d, e;
  93.    {
  94.    register nodeptr t;
  95.  
  96.    t = tfree;
  97.    tfree = (nodeptr) ((word *)tfree + 7);
  98.    if (tfree > tend)
  99.       tsyserr("out of tree space");
  100.    t->n_type = type;
  101.    t->n_file = loc_model->n_file;
  102.    t->n_line = loc_model->n_line;
  103.    t->n_col = loc_model->n_col;
  104.    t->n_field[0].n_ptr = c;
  105.    t->n_field[1].n_ptr = d;
  106.    t->n_field[2].n_ptr = e;
  107.    return t;
  108.    }
  109.  
  110. nodeptr tree6(type, loc_model, c, d, e, f)
  111. int type;
  112. nodeptr loc_model;
  113. nodeptr c, d, e, f;
  114.    {
  115.    register nodeptr t;
  116.  
  117.    t = tfree;
  118.    tfree = (nodeptr) ((word *)tfree + 8);
  119.    if (tfree > tend)
  120.       tsyserr("out of tree space");
  121.    t->n_type = type;
  122.    t->n_file = loc_model->n_file;
  123.    t->n_line = loc_model->n_line;
  124.    t->n_col = loc_model->n_col;
  125.    t->n_field[0].n_ptr = c;
  126.    t->n_field[1].n_ptr = d;
  127.    t->n_field[2].n_ptr = e;
  128.    t->n_field[3].n_ptr = f;
  129.    return t;
  130.    }
  131.  
  132. nodeptr int_leaf(type, loc_model, c)
  133. int type;
  134. nodeptr loc_model;
  135. int c;
  136.    {
  137.    register nodeptr t;
  138.  
  139.    t = tfree;
  140.    tfree = (nodeptr) ((word *)tfree + 5);
  141.    if (tfree > tend)
  142.       tsyserr("out of tree space");
  143.    t->n_type = type;
  144.    t->n_file = loc_model->n_file;
  145.    t->n_line = loc_model->n_line;
  146.    t->n_col = loc_model->n_col;
  147.    t->n_field[0].n_val = c;
  148.    return t;
  149.    }
  150.  
  151. nodeptr c_str_leaf(type, loc_model, c)
  152. int type;
  153. nodeptr loc_model;
  154. char *c;
  155.    {
  156.    register nodeptr t;
  157.  
  158.    t = tfree;
  159.    tfree = (nodeptr) ((word *)tfree + 5);
  160.    if (tfree > tend)
  161.       tsyserr("out of tree space");
  162.    t->n_type = type;
  163.    t->n_file = loc_model->n_file;
  164.    t->n_line = loc_model->n_line;
  165.    t->n_col = loc_model->n_col;
  166.    t->n_field[0].n_str = c;
  167.    return t;
  168.    }
  169.  
  170. nodeptr i_str_leaf(type, loc_model, c, d)
  171. int type;
  172. nodeptr loc_model;
  173. char *c;
  174. int d;
  175.    {
  176.    register nodeptr t;
  177.  
  178.    t = tfree;
  179.    tfree = (nodeptr) ((word *)tfree + 6);
  180.    if (tfree > tend)
  181.       tsyserr("out of tree space");
  182.    t->n_type = type;
  183.    t->n_file = loc_model->n_file;
  184.    t->n_line = loc_model->n_line;
  185.    t->n_col = loc_model->n_col;
  186.    t->n_field[0].n_str = c;
  187.    t->n_field[1].n_val = d;
  188.    return t;
  189.    }
  190.  
  191. /*
  192.  * Clear the tree space by setting the free pointer back to the first word
  193.  *  of the tree space.
  194.  */
  195.  
  196. novalue treeinit()
  197.    {
  198.    tfree = tree;
  199.    }
  200.